/**********************************************************************
*
*   strong_symbol.c
*   定义库里面部分WEAK函数的Strong函数，动态关闭库代码
***********************************************************************/
#include "include.h"

#if !FUNC_USBDEV_EN && !UDE_HID_BACKSTAGE_EN
void usb_dev_isr(void){}
void ude_ep_reset(void){}
void ude_control_flow(void){}
void ude_isoc_tx_process(void){}
void ude_isoc_rx_process(void){}
void lock_code_usbdev(void){}
#endif //FUNC_USBDEV_EN

#if USBDEV_REC_EN
u8 pff_buf[320] AT(.buf.pff);
u8* get_pff_buf(void)
{
    return pff_buf;     //use for dir_buf and sfn_buf
}
#endif  //USBDEV_REC_EN

#if (REC_TYPE_SEL != REC_MP3)
void mp3en_process(void){}
void lock_code_mp3enc(void){}
void mpa_encode_process(void){}
void lock_code_mp2enc(void){}
void unlock_code_mp2enc(void) {}
//void music_enc_process(u8 mq_msg) {}
int mp2_encode_frame(void) {return -1;}
#endif //(REC_TYPE_SEL != REC_MP3)

#if !SYS_KARAOK_EN
bool lock_code_karaok(u8 lock_num) {return false;}
void unlock_code_karaok(void) {}
AT(.com_text.karaok.proc)
void karaok_muisc_vol_fade_auto(void) {}
#endif

#if (!SYS_KARAOK_EN) || (!KARAOK_REC_EN)
#if(!MIC_AND_BT_REC_EN)
AT(.com_text.bt_rec)
bool karaok_rec_fill_buf(u8 *buf) {return false;}
#endif
AT(.com_text.krec)
void karaok_rec_process(s16* rptr, u32 samples){};
#endif

#if (!SYS_KARAOK_EN) || (!BT_HFP_CALL_KARAOK_EN)
AT(.com_text.ksco)
void karaok_sco_process(s16*rptr, u32 samples){};
#endif

#if (REC_TYPE_SEL != REC_ADPCM && !BT_HFP_REC_EN)
void adpcm_encode_process(void){}
#endif //(REC_TYPE_SEL != REC_ADPCM)

#if ((REC_TYPE_SEL != REC_SBC) && (!BT_HFP_MSBC_EN))
bool sbc_encode_init(u8 spr, u8 nch){return false;}
bool msbc_encode_init(void){return false;}
void sbc_encode_process(void){}
#endif

#if !MUSIC_WAV_SUPPORT
int wav_dec_init(void){return 0;}
bool wav_dec_frame(void){return false;}
void lock_code_wavdec(void){}
#endif // MUSIC_WAV_SUPPORT

#if !MUSIC_WMA_SUPPORT
int wma_dec_init(void){return 0;}
bool wma_dec_frame(void){return false;}
void lock_code_wmadec(void){}
#endif // MUSIC_WMA_SUPPORT

#if !MUSIC_APE_SUPPORT
int ape_dec_init(void){return 0;}
bool ape_dec_frame(void){return false;}
void lock_code_apedec(void){}
#endif // MUSIC_APE_SUPPORT

#if !MUSIC_FLAC_SUPPORT
int flac_dec_init(void){return 0;}
bool flac_dec_frame(void){return false;}
void lock_code_flacdec(void){}
#endif // MUSIC_FLAC_SUPPORT

#if !MUSIC_SBC_SUPPORT
int sbcio_dec_init(void){return 0;}
bool sbcio_dec_frame(void){return false;}
#endif // MUSIC_SBC_SUPPORT

#if !MUSIC_AAC_SUPPORT
int aacio_decode_init(void) {return 0;}
int aacio_dec_init(void) {return 0;}
#endif

#if !MUSIC_M4A_SUPPORT
int m4a_decode_init(void){return 0;}
int m4a_dec_init(void){return 0;}
bool aacio_sub_process(void){return true;}
#endif

#if !MUSIC_AAC_SUPPORT && !MUSIC_M4A_SUPPORT
bool aacio_dec_frame(void) {return false;}
#endif

#if !BT_AAC_AUDIO_EN
void aac_dec_init(void) {}
void aac_decode_init(void) {}
bool aac_dec_frame(void) {return false;}
bool aac_nor_dec_frame(void) {return false;};
bool aac_tws_dec_frame(void) {return false;};
void aac_cache_free_do(void) {}
size_t aac_cache_read_do(uint8_t *buf, uint max_size) {return 0;}
uint16_t tws_pack_aac(uint8_t *buf) {
    return 0;
}
AT(.com_text.aac.obuf)
void aac_fill_tws_obuf(void) {}
AT(.com_text.aac.cpy)
void aac_obuf_tws_cpy(u16 *aac_cache) {}
#else
void a2dp_play_reset(bool force){};
void aac_decode_init_do(void);
bool aac_dec_frame_do(void);
void aac_cache_free_do(void);
size_t aac_cache_read_do(uint8_t *buf, uint max_size);
AT(.text.music.init.aac)
void aac_decode_init(void) {
    aac_decode_init_do();
}
AT(.aacdec.text)
bool aac_dec_frame(void) {
    return aac_dec_frame_do();
}
//AT(.aacdec.text)
//void aac_cache_free(void) {
//    aac_cache_free_do();
//}
//AT(.aacdec.text)
//size_t aac_cache_read(uint8_t *buf, uint max_size) {
//    return aac_cache_read_do(buf, max_size);
//}
#endif

#if !FMRX_REC_EN
void fmrx_rec_start(void){}
void fmrx_rec_stop(void){}
void fmrx_rec_enable(void){}
#endif // FMRX_REC_EN

#if (!FMRX_REC_EN) && (!FMRX_MANUAL_GAIN_EN)
AT(.com_text.fmrx.dma.isr)
void fmrx_dma_isr(void){}
#endif

#if BT_SRCRAM_PHASECOM_SYNC
AT(.com_text.sbc_cache)
u8 bt_srcram_phasecom_sync(void) {
    return 1;
}
AT(.com_text.sbc_cache)
u8 rec_dac_out_spr(void){
    return DAC_OUT_SPR;
}
#endif

#if !BT_REC_EN && !DAC_DRC_EN && !DAC_VBS_EN && !DAC_SOFT_EQ_EN && !BT_SRCRAM_PHASECOM_SYNC && !SPI1_AUDIO_EN && !(DMA_IN_I2S_SEL == BT_DMA_I2S)
AT(.sbcdec.code.pcm)
void bt_sbc_pcm_output(u8 spr){}
AT(.com_text.bt_rec)
void bt_src_out_process(u8 all_done){};
#endif

#if !USB_SUPPORT_EN
void usb_isr(void){}
void usb_init(void){}
#endif

#if !SD_SUPPORT_EN
void sd_disk_init(void){}
void sdctl_isr(void){}
bool sd0_stop(bool type){return false;}

#if !FUNC_USBDEV_EN
bool sd0_init(void){return false;}
bool sd0_read(void *buf, u32 lba){return false;}
bool sd0_write(void* buf, u32 lba){return false;}
void sd_disk_switch(u8 index){};
#endif

#endif

#if !FUNC_MUSIC_EN
u32 fs_get_file_size(void){return 0;}
void fs_save_file_info(unsigned char *buf){}
void fs_load_file_info(unsigned char *buf){}
#endif // FUNC_MUSIC_EN

#if !BT_TWS_EN
void btstack_tws_init(void){}
void sbc_play_init(void){}
AT(.com_text.sbc.play)
void sbc_play_reset(void){}
AT(.com_text.sbc.play)
void sbc_cache_reset(void){}

AT(.com_text.sbc_cache)
bool sbc_cache_fill(uint8_t *packet, uint16_t size) {
    return true;
}

AT(.com_text.sbc_cache)
uint8_t avdtp_fill_tws_buffer(u8 *ptr, uint len) {
    return 0;
}

AT(.com_text.sbc_cache)
uint8_t sbc_cache_before_rx(uint8_t *data_ptr, uint16_t data_len) {
    return 0;
}

AT(.sbcdec.code)
void sbc_cache_free(void) {
}

AT(.sbcdec.code)
size_t sbc_cache_read(uint8_t **buf) {
    return 0;
}

AT(.com_text.bb.tws)
void tws_timer_isr(void) {
}

AT(.com_text.bb.btisr)
void lc_tws_hssi_instant(uint8_t Lid) {
}

AT(.com_text.bb.btisr)
uint8_t lc_get_ticks_status(void) {
    return 0x80;
}

uint8_t lc_tws_set_spr(uint8_t Lid, uint SprIdx, uint32_t Hssi) {
    return 0;
}

AT(.com_text.sbc.play)
void tws_ticks_trigger(uint32_t ticks) {
}

AT(.com_text.sbc.play)
uint32_t tws_get_play_ticks(uint32_t frame_num) {
    return 0;
}

AT(.com_text.sbc.play)
void tws_trigger_isr(void) {
}

AT(.com_text.sbc.play)
bool tws_cache_is_empty(void) {
    return false;
}

AT(.com_text.sbc.play)
void sbc_cache_env_reset(void)
{
}

AT(.com_text.sbc.send)
void tws_send_pkt(void)
{
}
#else
//固定主副耳
#if (BT_TWS_CONN_TYPE == 1)
void btstack_tws_init_ms(void);
void btstack_tws_init(void) {
    btstack_tws_init_ms();
}
#endif
#endif

#if !BT_TWS_EN || !BT_TSCO_EN
void lc_tsco_init(void) {
}
AT(.com_text.bb.tws.sco)
void ext_lc_tsco_slot_check(uint32_t clock) {
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_get_active_acl(uint32_t clock, uint8_t *next_lid) {
    return false;
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_rx(void *conn, uint8_t rx_type, uint8_t *ptr) {
    return false;
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_tx_ack(void *conn, uint8_t tx_type, uint txptr) {
    return false;
}
AT(.com_text.bb.tws.sco)
void ext_lc_tsco_clr_tx_sta(void) {}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_put_txpkt(uint8_t *rx_buf, uint8_t pkt_len, bool pkt_stat) {
    return true;
}
AT(.com_text.bb.tws.sco)
void ext_lc_fill_tsco_dat(void) {
}
void ext_lc_tsco_flush_txbuf(uint8_t lid, bool clr_phdr) {
}
void lc_tsco_send_setup(uint8_t sco_lid, uint8_t flags, uint8_t dsco, uint8_t tsco, uint8_t pkt_len, uint8_t air_mode) {
}
void lc_tsco_send_kill(uint8_t acl_lid) {
}
void lc_tsco_remote_setup(uint8_t lid, uint8_t *param) {
}
void lc_tsco_remote_kill(uint8_t lid, uint8_t *param) {
}
void lc_tsco_free_link(uint8_t lid) {
}
AT(.bt_voice.bb.tws.sco)
uint8_t ext_lc_tsco_get_status(void) {
    return 0;
}
#else
#if BT_TSCO_VER == 1
void lc_tsco_init_v1(void);
void ext_lc_tsco_slot_check_v1(uint32_t clock);
bool ext_lc_tsco_get_active_acl_v1(uint32_t clock, uint8_t *next_lid);
bool ext_lc_tsco_rx_v1(void *conn, uint8_t rx_type, uint8_t *ptr);
bool ext_lc_tsco_tx_ack_v1(void *conn, uint8_t tx_type, uint txptr);
void ext_lc_tsco_clr_tx_sta_v1(void);
bool ext_lc_tsco_put_txpkt_v1(uint8_t *rx_buf, uint8_t pkt_len, bool pkt_stat);
void ext_lc_tsco_flush_txbuf_v1(uint8_t lid, bool clr_phdr);
uint8_t ext_lc_tsco_get_status_v1(void);
void ext_lc_fill_tsco_dat_v1(void);
void lc_tsco_send_setup_v1(uint8_t sco_lid, uint8_t flags, uint8_t dsco, uint8_t tsco, uint8_t pkt_len, uint8_t air_mode);
void lc_tsco_send_kill_v1(uint8_t acl_lid);
void lc_tsco_remote_setup_v1(uint8_t lid, uint8_t *param);
void lc_tsco_remote_kill_v1(uint8_t lid, uint8_t *param);
void lc_tsco_free_link_v1(uint8_t lid);

void lc_tsco_init(void) {
    lc_tsco_init_v1();
}
AT(.com_text.bb.tws.sco)
void ext_lc_tsco_slot_check(uint32_t clock) {
    ext_lc_tsco_slot_check_v1(clock);
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_get_active_acl(uint32_t clock, uint8_t *next_lid) {
    return ext_lc_tsco_get_active_acl_v1(clock, next_lid);
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_rx(void *conn, uint8_t rx_type, uint8_t *ptr) {
    return ext_lc_tsco_rx_v1(conn, rx_type, ptr);
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_tx_ack(void *conn, uint8_t tx_type, uint txptr) {
    return ext_lc_tsco_tx_ack_v1(conn, tx_type, txptr);
}
AT(.com_text.bb.tws.sco) WEAK
void ext_lc_tsco_clr_tx_sta(void) {
    ext_lc_tsco_clr_tx_sta_v1();
}
AT(.com_text.bb.tws.sco)
bool ext_lc_tsco_put_txpkt(uint8_t *rx_buf, uint8_t pkt_len, bool pkt_stat) {
    return ext_lc_tsco_put_txpkt_v1(rx_buf, pkt_len, pkt_stat);
}
AT(.bt_voice.bb.tws.sco)
uint8_t ext_lc_tsco_get_status(void) {
    return ext_lc_tsco_get_status_v1();
}
AT(.com_text.bb.tws.sco)
void ext_lc_fill_tsco_dat(void) {
    ext_lc_fill_tsco_dat_v1();
}
void ext_lc_tsco_flush_txbuf(uint8_t lid, bool clr_phdr)
{
    ext_lc_tsco_flush_txbuf_v1(lid, clr_phdr);
}
void lc_tsco_send_setup(uint8_t sco_lid, uint8_t flags, uint8_t dsco, uint8_t tsco, uint8_t pkt_len, uint8_t air_mode)
{
    lc_tsco_send_setup_v1(sco_lid, flags, dsco, tsco, pkt_len, air_mode);
}
void lc_tsco_send_kill(uint8_t acl_lid)
{
    lc_tsco_send_kill_v1(acl_lid);
}
void lc_tsco_remote_setup(uint8_t lid, uint8_t *param)
{
    lc_tsco_remote_setup_v1(lid, param);
}
void lc_tsco_remote_kill(uint8_t lid, uint8_t *param)
{
    lc_tsco_remote_kill_v1(lid, param);
}
void lc_tsco_free_link(uint8_t lid)
{
    lc_tsco_free_link_v1(lid);
}
#endif // BT_TSCO_VER==1
uint32_t bt_get_tsco_vers(void) {
    return BT_TSCO_VER;
}
bool bt_tsco_is_en(void) {
    return BT_TSCO_EN;
}
#endif

#if BT_FCC_TEST_EN
void ble_tx_test_do(void *param);
void ble_tx_test(void *param)
{
    ble_tx_test_do(param);
}
#endif // BT_FCC_TEST_EN

#if !BT_FCC_TEST_EN && !BT_BQB_TEST_EN
void huart_init(void)
{
}
AT(.com_text.stack.uart_isr)
bool bt_uart_isr(void) {
    return false;
}
#endif

#if BT_RF_BIAS_ADD
void rf_bias_add_init_do(void);
void rf_bias_add_init(void)
{
    rf_bias_add_init_do();
}
#endif

#if BT_RF_LPWR_EN
bool bt_rf_is_lpwr_en(void) {
    return true;
}
#else
AT(.com_text.voltage.vbko)
void pmu_set_vbko(u32 rfs) {
}
#endif

#if (!SYS_MAGIC_VOICE_EN) && (!BT_SCO_MAV_EN) && (!AUDIO_STRETCH_EN)
void magic_voice_process(void){}
void mav_kick_start(void){}
#endif


#if (!AUDIO_STRETCH_EN)
void stretch_dual_voice_process(void *buf, u16 frame_len){}
void speed_voice_process(void){}
void speed_kick_start(void){}

#endif

#if !FUNC_SPDIF_EN && !FUNC_HDMI_EN
void spdif_process(void){}
bool spdif_smprate_detect(void) {    return false;}
void spdif_isr(void){}
#endif

#if !BT_HFP_REC_EN
AT(.com_text.bt_rec)
void bt_sco_rec_mix_do(u8 *buf, u32 samples) {}
void bt_sco_fill_remote_buf(u16 *buf, u16 samples) {}
#endif

#if !DAC_DRC_EN && !DAC_SOFT_EQ_EN &&!DAC_XDRC_EN
AT(.com_text.soft_eq)
s32 dac_soft_eq_proc(u8 lr, s32 input){return input;}
AT(.com_text.soft_eq)
s32 dac_soft_eq_proc_lp(u8 lr, s32 input){return input;}
AT(.com_text.soft_eq)
s32 dac_soft_eq_proc_hp(u8 lr, s32 input){return input;}
AT(.com_text.soft_drc)
void soft_eq_drc_stereo_proc(s16 *ldata, s16 *rdata){}
AT(.com_text.soft_drc)
void soft_eq_drc_mono_proc(s16 *data){}
AT(.com_text.soft_drc)
void drc_stereo_process(s32 *ldata, s32 *rdata, void* drc){};
#if !PCM_DRC_EN  //drc可能会单独使用
AT(.com_text.soft_drc)
void drc_mono_process(s32 *data, void* drc){};
#endif

#endif

#if !DAC_VBS_EN
void vbass_process(s16 *ldata, s16 *rdata) {}
#endif

#if !I2S_EN
void i2s_process(void){}
void i2s_isr(void){}
AT(.com_text.i2s.clk)
void i2sclk_select(u8 iisclk_ch ,u8 iis_div){}
#endif

#if !LE_EN
AT(.com_text.bb.leisr)
void ble_isr(void) {}
AT(.com_text.bb.leisr.evt)
void ble_evt_instant(void *evt, uint32_t *next_basetimecnt, bool role) {}
AT(.com_text.bb.leisr.loop)
void ble_evt_schedule(void) {}
AT(.com_text.bb.leisr.time)
uint32_t ble_evt_time_get(void) { return 0; }
AT(.com_text.bb.leisr.adv_data)
uint8_t llm_set_adv_data(void const *param) { return 0; }
AT(.com_text.bb.leisr.adv_update)
void ble_lm_adv_data_update(void) {}
AT(.com_text.bb.leisr.update)
void ble_lc_check_update_evt_sent(uint16_t conhdl, void *evt_new) {}
AT(.com_text.bb.leisr.free)
void ble_evt_free_do(void *evt) {}

void llc_con_update_ind(uint16_t conhdl, void *evt_new) {}
void llc_con_update_cmd_complete_send(uint8_t status, uint16_t conhdl, void *evt) {}
void llc_map_update_ind(uint16_t conhdl) {}
void llc_common_nb_of_pkt_comp_evt_send(uint16_t conhdl, uint8_t nb_of_pkt) {}

void ble_ll_init(void) {}
void ble_ll_reset(void) {}
bool ble_event_cmd_complete(uint8_t *packet, int size) { return false; }
void ble_event_meta(uint8_t *packet, int size) {}
int att_server_notify_do(void) { return 1;}
void hci_run_le_connection(void) {}
void btstack_ble_init(void) {}
void btstack_ble_send(void) {}
void btstack_ble_update_conn_param(void) {}
#endif

#if !LE_SCAN_EN
AT(.com_text.bb.ble)
void ble_tiny_isr(void) {}
AT(.com_text.bb.ble)
bool ble_tiny_is_busy(void) {return false;}
AT(.com_text.bb.ble)
void ble_tiny_clock_isr(uint32_t clock) {}
void ble_tiny_init(void) {}
uint8_t ble_tiny_scan_start(void) {return 0;}
uint8_t ble_tiny_scan_stop(void) {return 0;}
uint8_t ble_tiny_scan_status(void) {return 0;}
void ble_tiny_set_scan_param(uint16_t interval, uint16_t window) {}
#endif

#if !AUX_DNR_EN
AT(.com_text.dac.dnr)
u8 aux_noise_detect(u16 pow){ return 0;};
AT(.com_text.func.aux)
void aux_dnr_detect(void *buf, u16 len){};
#endif

#if !SINE_TONE_EN
AT(.com_text.dac)
bool sine_tone_fill_buf1(void) {return false;}
AT(.com_text.dac)
void sine_tone_stop(void){}
#endif

#if (!FMRX_DNR_EN) && (!DAC_AUCAR_EN)
u16 fmrx_dnr_process(s16 *buff,u32 len, u16 gain) {return gain;}
#endif

#if (!FMRX_DNR_EN) && (!DAC_AUCAR_EN)
void fmrx_manual_gain_process(bool half_done){};
#endif


#if !BT_SPEEX_EN
void speex_process(void) {}
void spx_kick_start(void) {}
#endif

#if !BT_SCO_AINS2_EN
void ains2_process(s16 *data){}
void ains2_init(u32 nt, u8 fre_mid_min, u8 fre_high_min){}
#endif

#if !BT_SCO_DUMP_EN
void sco_huart_putcs(u8 type, const void *buf, uint len){}
void sco_huart_init(void){}
#endif

#if !BT_PBAP_EN
void pbap_client_init(uint8_t rfcomm_channel_nr) {}
void btstack_pbap(uint16_t param) {}
void btstack_pbap_pullphonebook_continue_time(uint16_t time){}
#endif

#if !BT_MAP_EN
void map_client_init(uint8_t rfcomm_channel_nr) {}
void btstack_map(uint16_t param) {}
void bt_get_time(char *ptr, uint32_t len, uint8_t format){};
#endif

#if !(BT_PBAP_EN || BT_MAP_EN)
void goep_client_init() {}
#endif


#if !DAC_SOFT_EQ_EN
s16 dac_soft_eq_r_proc(s16 input) { return 0; }
s16 dac_soft_eq_l_proc(s16 input) { return 0; }
#endif

#if !BT_SCO_FAR_NR_EN && !BT_SCO_FAR_DNR_EN
void nr_process(s16 *data) {}
void nr_init(u16 nt) {}
void bt_sco_nr_process(u16 *ptr, u8 len) {}
#endif

#if !SYS_KARAOK_NR_EN
void karaok_buf_nr_init(u16 nt){}
s16* karaok_echo_get_buf_thin(u32 buf_num) { return 0; }
uint karaok_echobuf_thin_next(void) { return 0; }
#endif

#if KARAOK_RECMIC_ONLY
AT(.com_text.sdadc)
void karaok_sdadc_process_do(u8 *ptr, u32 samples, int ch_mode){}
#else
AT(.com_text.karaok.proc)
void karaok_recmic_only_process(s16 *ptr, u32 samples, int ch_mode){}
#endif

#if SYS_ECHO_MIC_HALF_EN
u16 user_echo_size = 64;
#endif // SYS_ECHO_MIC_HALF_EN

#if !BT_SCO_SRC_EN
void bt_sco_src_init(void) {}
void bt_sco_src_exit(void) {}
void bt_sco_src_kick_start(u16 *in) {}
#else
u8 bt_sco_far_nr_en(void)
{
    return BT_SCO_SRC_EN;
}
#endif
#if UART_S_UPDATE
WEAK u8 get_uart_upd (u8 *ch){
    return 0;
}
AT(.com_text.uart_isr)
WEAK void put_upd_uart_msg(void)
{
}
WEAK void uart_upd_isr_disable(void)
{

}
#endif // UART_S_UPDATE

#if !MUSIC_PLAY_POINT_EN
void music_set_play_time(u32 second) {}
void first_offset_init(void *brkpt) {}
uint32_t get_first_offset(void) { return 0;}
u32 ape_frame_jump_cal(u32 frame) { return 0;}
void music_random_time_init(void){}
#endif

#if !BT_TOUCH_SCREEN_EN
void btstack_hid_touch_screen(uint16_t keycode)
{
}
const uint8_t hid_service_tscreen_buffer[1] = {0};
const uint8_t hid_service_tscreen_buffer_ext[1] = {0};
#endif

#if !BT_HID_MOUSE_EN
const uint8_t hid_service_mouse_buffer[1] = {0};
void bt_hid_mouse_action_para_store(hid_mouse_action_t *action)
{
}
void btstack_hid_mouse_impl(void)
{
}
bool bt_hid_mouse_action_send(void *action)
{
    return false;
}
#endif

#if BT_ID3_TAG_EN
bool bt_id3_en(void)
{
    return BT_ID3_TAG_EN;
}
#endif

#if (!UDISK_SECTOR_4K_EN)
u8 disk_sector_4k_en(void){ return 0; }
void disk_sector_4k_init(u8 (*buff)[512]){}
#endif

#if !BT_HSP_EN
void hsp_hs_init(uint8_t rfcomm_channel_nr) {}
void hsp_hs_connect(u8* bd_addr) {}
void btstack_hsp_key(uint16_t keycode) {}
void hsp_hs_disconnect(void) {}
#endif


#if !SYS_OVERCLK_SEL
AT(.com_text.overclk)
bool sys120m_overclk_pllset(void) {return 0;};
#endif

#if !KARAOK_DENOISE_EN && !BT_SCO_FAR_DNR_EN
AT(.com_text.mic_dnr)
void micdnr_process(void *buf, u32 samples) {}
#endif

#if I2S_EN && (DMA_IN_I2S_SEL == BT_DMA_I2S)
AT(.com_text.iis_cache)
bool is_bt_to_i2s_en(void) {
    return 1;
}
#else
AT(.com_text.i2s)
void *read_i2s_dma_outbuf(void){return NULL;}
AT(.com_text.i2s)
void wirte_i2s_dma_outbuf(void* buf,u16 sample){}
AT(.com_text.i2s)
void memcpy_16bit_2_32bit(int cnt,void *buf_dat,void *buf) {}
#endif // BT_DMA_I2S_EN
#if I2S_EN && (DMA_IN_I2S_SEL==SPDIF_DMA_I2S)
AT(.com_text.i2s)
bool is_spdif_to_i2s_en(void){ return 1;}
#else
AT(.com_text.i2s)
void set_i2s_baud(u8 baud){}
AT(.com_text.i2s)
void set_i2s_adpll_div(u8 type){}
AT(.com_text.i2s)
void put_i2s_buf(void *buf, u8 len){}
#endif

#if (DMA_OUT_I2S_SEL != I2S_DMA_BT || !I2S_EN) && (!IIS_RX_2_SCO_SRC)
void src_isr(void){}
void src_init(u8 spr){}
void src_kick_start(u8 * buf){}
void src_exit(u8 *buf){}
void src_out_process(u8 all_done){}
void iis2bt_sco_process(u8 *ptr, u32 samples, int ch_mode){}
void iis_to_bt_sco_process(u8 *buf){}
void iis2bt_sco_sync_init(void){}
#endif // DMA_OUT_I2S_SEL
//修正使用骁龙660平台(小米6X,OPPO K1)卡顿问题
AT(.com_text.bt.pwr)
bool bt_dis_pwr_saving(void)
{
    return true;
}

#if FOT_EN
u8 is_fot_update_en(void)
{
    return 1;
}
#endif

#if SYS_REVERB_EN
AT(.com_text.reverb_func)
bool reverb_func_is_en(void)
{
    return 1;
}
#else
AT(.com_text.reverb)
void set_wet_gain_level(u8 level) {}
AT(.com_text.reverb)
s32 allpass_type(s32 x_in, s32 x_in_delay, s32 y_out_delay) { return 0; }
AT(.com_text.reverb)
s32 iir_lpf(s32 x_in, s32 y_out) { return 0; }
AT(.com_text.reverb)
s32 comb_filter_diff(s16 x_data, s32 y_data, int comb) { return 0; }
void reverb_start(void) {}
AT(.com_text.reverb)
void reverb_flow_new(s16 * obuf, const s16 * ibuf) {};
AT(.com_text.reverb)
void reverb_flow_process(s16 *rptr, u16 samples){};
#endif

#if BT_BACKSTAGE_PLAY_DETECT_EN
AT(.com_text.sbc1)
void avdtp_acl2_sbc_compare_buf(uint8_t *data_ptr){};
#endif

#if !UNICODE_BIG5_EN
void gb2312_clear(void){}
void is_gb_2312_code(const unsigned char *ptr,long ptr_size){}
void gb2312_to_unicode (unsigned char *s, size_t n){}
void big5_to_unicode (unsigned char *s, size_t n){}
void chardet_process(const unsigned char *ptr,long ptr_size) {}
u8 get_charcode(void **p){return 0;}
#endif // UNICODE_BIG5_EN

#ifndef BT_AAC_AUDIO_EN
u32 __code_start_aac, __code_end_aac;  //兼容旧版本
#endif

#if USB_EP0_EIGHT

bool is_enable_ep0_eight_byte(void){ return 1; }
#endif // USB_EP0_EIGHT

#if LRC_ENCRYPT_EN
AT(.text.lrc)
u8 get_lrc_encrypt_flag(void)
{
    return f_msc.lrc_encrypt;
}
#endif // LRC_ENCRYPT_EN
#if !ULP_PLAY_MP3
int fs_read_buff(void *buf, unsigned int size, unsigned int len){return 0;}
#endif


#if !BT_SDP_SEARCH_UUID_EN
void btstack_sdp_client_search_l2cap(void){}
void sdp_client_search_l2cap(void *remote_addr){}
#endif

#if BT_CARPLAY_EN
bool bt_is_carplay_en() {
    return true;
}
#endif


#if !KARAOK_MIC_DRC
AT(.com_text.karaok_drc)
s16 drc_calc(s32 sample, u8 drc_cb_i){return 0;}
AT(.com_text.karaok_drc)
int drc_calc_dmic(s32 sample_l, s32 sample_r, u8 drc_cb_i){return 0;}
AT(.com_text.karaok_drc)
bool karaok_drc_init(const void *bin, int bin_size, u8 drc_cb_i){return 0;}
AT(.com_text.karaok_drc)
bool sdadc_drc_init(u8 *drc_addr, int drc_len){return 0;}
AT(.com_text.karaok_drc)
void drc_mic_audio_input(u8 *ptr, u32 samples, int ch_mode, void *params){}
AT(.com_text.karaok_gain)
int karaok_mic_gain_tbl[32] ={};
#endif

#if !SYS_PITCH_SHIFT
AT(.com_text.pitch_shift_pro)
int pitch_shift2_process(s16 *data){return 0;}
#endif

#if !BT_HID_MOBILE_REMOTE_CONTROL
const uint8_t hid_service_mobile_remote_control_buffer[1] = {0};
typedef u8 remote_control_e;
void btstack_hid_mobile_remote_control(remote_control_e key){};
void btstack_hid_mobile_remote_control_send(uint16_t len){};
#endif

